Commodore Free 26/Commodore_Free_Issue_26_2009_Commodore_Computer_Club.d64/creating tap fil

Text File | 2009-01-01 | 5.7 KB | 184 lines

u

          CREATING TAP FILES
          ------------------
    http://tapes.c64.no/index.php

For now, this article won't go into
deep details about the transfer
process, since this is documented in
other places. However The recommended
way to transfer tapes is using a real
C64 datasette. For PC-users, this is
best done with mtap by Markus Brenner.
You can download the application at
his web site at
http://markus.brenner.de. Another
pretty common way to transfer tapes,
is through sampling it with a sound
card using a HiFi-tapedeck. DON'T DO
IT!!!! It's a TERRIBLE way of dumping
tapes, and the error-rate is VERY
high. It's quite high even using a
real datasette.

Okay, you have everything you need now
(I assume that you've read the
instructions found in the mtap-archive
found at Markus Brenner's site), and
if you follow these simple, but
time-consuming steps, you will soon be
making the best TAP-files that can be
made.

1. Dump the same title several times.

Yes, it IS time-consuming, but it is
the only way to make sure you get all
data is pulled out from the tape.
Often when reading these old
treasures, a few pulses may be misread
for different reasons. Especially on
lower quality tapes. This is critical,
because you may not always get any
clues that the tape infant WAS
misread. Even if some pulses are
wrong, it may load and appear to be
working. Some loaders have implemented
checksums. A checksum is a value that
is created by adding the read bytes
into a sum. At the end of the file,
the final sum is compared to the sum
that is expected by the loader. These
loaders aren't as demanding, but
they're not 100% foolproof either.

The positive thing is that noisy, worn
out tapes, USUALLY produces random
errors. Using a TAP-scanner and
cleaner (in this text, I'll be
referring to my good friend Stewart
Wilson's FinalTAP, since it's probably
the best TAP-tool released at the time
being), we can detect a lot of things.
We can detect loadertype, if a
checksum is present, and if it's OK.
FinalTAP also creates crc32 values of
the data. Both single files and the
entire data. This is very useful since
we then can compare different dumps of
the same tape.

As a rule of thumb, you should have at
least two identical dumps before you
can assume the TAP is OK. I recommend
at least three dumps for loaders not
containing their own checksum since
they are more vulnerable. It's not
likely that you have two identical
TAPs which are faulty, but you can
never be 100% sure. It's better to do
one extra dump just to make sure the
data is OK. If you can get the same
title from several sources (assuming
the other sources has the same version
as you), that's even better. If two
dumps from two different sources, even
different sides of a tape turns out
identical, you're 99,9% sure that your
dump is completely error free.

Sometimes, the content from two
different sources may vary slightly.
This could be very confusing for the
inexperienced, and also sometimes for
the more experienced TAP-maker. That
doesn't HAVE to mean it is an error
(unless it fails to load, or an
internal checksum indicates so). It's
actually common with very small
differences in "unused memory" in
certain loaders (Novaload being an
example of this). The software
companies had written the game
including random garbage bytes present
in RAM at the time and those bytes may
differ two different recordings, even
on the same tape. This is
unfortunately something we cannot do
anything about, but I would advise you
to try locating the differences to see
if it can be any harm. An article on
this subject will come later.

2. Time to clean up!

Well, you now have a functional tape?
Congratulations. Now we want to clean
it up. As we've mentioned, old tapes
are noisy and the need to be freshened
up a little. FinalTAP also has
functions for that. Actually, that is
FinalTAP's main purpose. By pressing
the "optimize"-button, FinalTAP
flattens out the signals of recognised
files and removes any noise that it
may detect. This has at least two
advantages. You get files that are
excellent as master tapes for writing
back to real tapes again (these tapes
will actually turn out cleaner and
nicer than the originals you have),
and the files will compress much
better, which is nice if you want to
share your tapes on the net.

Due to the way FinalTAP works, it may
happen that not all noise is being
removed entirely. This is because it
does NOT touch anything it doesn't
recognise. This is your guarantee that
FinalTAP won't damage your TAP-image.
In these cases, manual hex-editing is
necessary if you want a perfect TAP.
This is not recommended for
inexperienced TAP-makers, because you
could end up damaging the TAP if you
don't know exactly what you are doing.
The leftovers from FinalTAP will not
harm the tape in any way, and the tape
should still load fine on a real C64.

You should be aware of the fact that
FinalTAP does not support all the
different loaders out there, and
probably never will, but it supports
all of the most common loaders. You
should also make sure that 100% of the
TAP is detected. In some cases where
some noise hasn't been removed, it
will say it detected 99% after
optimizing/cleaning. An unprocessed
TAP may have down to 97% detected
(This is the lowest value I've found
myself so far).

3. ALWAYS save ALL your raw dumps

This is very important, because you
can always clean a TAP, but never go
back IF the process went wrong. The
raw files can also be useful for
research and developing utilities for
those into that.

I hope by writing this article I've
managed to give you a clue on how to
succeed in making the best possible
TAP-files for the community. If
there's something you feel is not
answered here, or you need some other
help, feel free to contact me